1. Field of the Invention
The present invention relates in general to the field of computers and similar technologies, and in particular to software utilized in this field. Still more particularly, it relates to a method, system and computer-usable medium for managing virtual processor operations.
2. Description of the Related Art
Software applications are bound to the processor architecture upon which they execute. Flexible software applications are typically able to probe the processor or query the operating system (OS), and in turn, the processor or OS will return the current architecture. However, it may be desirable for the application to execute as if it were running on a processor architecture that is different than what it is actually running upon. Known approaches to this issue include hardware processor architecture emulation, or compatibility mode, where the processor is able to emulate a different (e.g., older) processor architecture. However, compatibility mode may not always be available. Furthermore, compatibility mode may require rebooting the system to change the processor mode. Moreover, compatibility mode may operate system-wide and as a result, impact other, unrelated software applications executing on the same system.
Another approach is software processor architecture emulation, where a virtual machine (VM) is implemented to emulate a processor architecture that is different than the architecture that it is actually running upon. However, VMs require an additional OS instance, which executes within the VM. Furthermore, VMs require processor support to intercept attempts to execute instructions that are not supported by the actual processor. Moreover, this support may not be available for all emulated instructions. In addition, this support, when available, degrades the performance of the application running in the VM.
Other known approaches include software application modification, where the software application may be modified to emulate a processor architecture that is different from what is actually being used. However, application modification is not always possible because source code and build chains may not be available. Furthermore, the modification, testing and deployment of a new application may be operationally disruptive and financially expensive. Moreover, modifying the application may not be sufficient, as system libraries used by the application may also query the operating system about the processor architecture. In view of the foregoing, there is a need for being able to select a predetermined processor architecture, different from what is actually being used, to execute a target software application during its lifetime.